home *** CD-ROM | disk | FTP | other *** search
/ Archive Magazine CD 1995 / Archive Magazine CD 1995.iso / discs / prog_disc / volume_7 / issue_07 / drawfile / !RendDraw / c / file < prev    next >
Encoding:
Text File  |  1993-06-17  |  18.5 KB  |  724 lines
  1. /*
  2.  * Name   : file.c
  3.  * Desc   : whole/part file handling for manual program
  4.  * Author : James Bye
  5.  * Date   : 15th October 1991
  6.  *
  7.  * History
  8.  * -------
  9.  *
  10.  *  15-Oct-91  JAB  Created this file
  11.  *
  12.  *
  13.  * This source will be part of the manual software code library
  14.  */
  15.  
  16.  
  17. /*************************************************
  18.  * Include files                                 *
  19.  *************************************************/
  20.  
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24. #include "kernel.h" 
  25.  
  26. #include "file.h"
  27.  
  28. /*************************************************
  29.  * Static variables                              *
  30.  *************************************************/
  31.  
  32.  
  33. static _kernel_oserror  *last_oserror = NULL; /* the last os error */
  34.  
  35.                                                    
  36.  
  37. /**********************************************************
  38.  * OS_File calls                                          *
  39.  * -------------                                          *
  40.  *                                                        *
  41.  * These calls call the SWI' as detailed in the RISC OS   *
  42.  * v2.00 PRM                                              *
  43.  *                                                        *
  44.  * They deal mainly with whole files, such as:-           *
  45.  *                                                        *
  46.  *    Loading                                             *
  47.  *    Saving                                              *
  48.  *    Writing catalogue information                       *
  49.  *    Reading catalogue information                       *
  50.  *    etc...                                              *
  51.  *                                                        *
  52.  **********************************************************/
  53.  
  54.  
  55.   
  56. /*************************************************
  57.  * Reason codes etc                               *
  58.  *************************************************/
  59.  
  60. /*-- OS File --*/
  61.  
  62. #define OS_File    0x08
  63. #define SaveBlock    10
  64. #define ReadCat       5
  65. #define Delete        6
  66. #define CreateFile   11
  67. #define CreateDir     8
  68. #define LoadFile    255
  69.  
  70.  
  71. /*
  72.  * Name : file_lasterror
  73.  * Desc : returns the last error encountered by this module
  74.  * In   : None
  75.  * Out  : pointer to error block
  76.  */
  77.  
  78. extern _kernel_oserror *file_lasterror ( void )
  79. {
  80.   return(last_oserror);
  81. }
  82.  
  83.  
  84. /*
  85.  * Name : file_memdump
  86.  * Desc : dumps memory to a file
  87.  * In   : char *filename   - pointer to a filename
  88.  *        int   filetype   - filetype number
  89.  *        char *buffer     - pointer to a buffer
  90.  *        int   size       - size of buffer
  91.  * Out  : pointer to error block
  92.  */
  93.  
  94. extern _kernel_oserror *file_memdump ( char *filename, int filetype,
  95.                                        char *buffer, int size       )
  96. {
  97. _kernel_swi_regs r;
  98.  
  99.   r.r[0] = SaveBlock;
  100.   r.r[1] = (int) filename;
  101.   r.r[2] = filetype;
  102.   r.r[4] = (int) buffer;
  103.   r.r[5] = ((int) buffer) + size;
  104.   last_oserror = _kernel_swi(OS_File,&r,&r);
  105.   return(last_oserror);
  106. }
  107.  
  108.                      
  109.  
  110. /*
  111.  * Name : file_writecat
  112.  * Desc : a group of functions that deal with catalogue writing
  113.  *        they are prototyped as follows :-
  114.  *
  115.  *    file_writecat1  - writes load address,exec address,attribs to file
  116.  *    file_writecat2  - writes load address only
  117.  *    file_writecat3  - writes execution address only
  118.  *    file_writecat4  - writes attribs only
  119.  *    file_writecat9  - date/time stamp; filetype to data
  120.  *    file_writecat18 - set filetype and stamp
  121.  *
  122.  * In  : int   code- reason code           
  123.  *       char *p   - pathname
  124.  *       int   r2  - register value for R2 - depending on call
  125.  *       int   r3  - register value for R3 - depending on call
  126.  *       int   r5  - register value for R5 - depending on call
  127.  * Out : pointer to error block
  128.  * Info: for call 1  - r2:  load address
  129.  *                     r3:  exec address
  130.  *                     r5:  attribs
  131.  *       for call 2  - r2:  load address
  132.  *       for call 3  - r3:  execution address
  133.  *       for call 4  - r5:  attribs
  134.  *       for call 9  - None
  135.  *       for call 18 - r2:  filetype
  136.  */
  137.  
  138. #ifndef __writecat_protos
  139. #define file_writecat1(p,load_addr,exec_addr,attribs) file_writecat(1,p,load_addr,exec_addr,attribs)
  140. #define file_writecat2(p,load_addr)                   file_writecat(2,p,load_addr,0,0)
  141. #define file_writecat3(p,exec_addr)                   file_writecat(3,p,0,exec_addr,0)
  142. #define file_writecat4(p,attribs)                     file_writecat(4,p,0,0,attribs)
  143. #define file_writecat9(p)                             file_writecat(9,p,0,0,0)
  144. #define file_writecat18(p,filetype)                   file_writecat(18,p,filetype,0,0)
  145. #endif
  146.  
  147. extern _kernel_oserror *file_writecat ( int code, char *p, int r2, int r3, int r5 )
  148. {
  149. _kernel_swi_regs  r;
  150.  
  151.   r.r[0] = code;
  152.   r.r[1] = (int) p;
  153.   r.r[2] = r2;
  154.   r.r[3] = r3;
  155.   r.r[5] = r5;
  156.   last_oserror = _kernel_swi(OS_File,&r,&r);
  157.   return(last_oserror);
  158. }
  159.  
  160.  
  161.  
  162. /*
  163.  * Name : file_readcat
  164.  * Desc : reads catalogue information for a file
  165.  * In   : char *filename   - pointer to a filename
  166.  *        int  *type       - pointer for the type
  167.  *        int  *laddr      - pointer for load address 
  168.  *        int  *eaddr      - pointer for exec address
  169.  *        int  *length     - pointer for length
  170.  *        int  *attrib     - pointer for attributes
  171.  * Out  : returns pointer to error block
  172.  * Info : any of the destination pointer can set to NULL and if so
  173.  *        then they will not be written to
  174.  *        to find the size only, you would call as follows :-
  175.  *         file_readcat(filename,NULL,NULL,NULL,&size,NULL);
  176.  */                                                    
  177.  
  178. #define IfPtrThenWrite(ptr,d) if(ptr != NULL) *ptr = d
  179.  
  180. extern _kernel_oserror *file_readcat ( char *filename, int *type, int *laddr, int *eaddr,
  181.                                        int *length, int *attrib )
  182. {
  183. _kernel_swi_regs  r;
  184.  
  185.   r.r[0] = ReadCat;
  186.   r.r[1] = (int) filename;
  187.   last_oserror = _kernel_swi(OS_File,&r,&r);
  188.   if(last_oserror == NULL)
  189.   {                                
  190.      IfPtrThenWrite(type,r.r[0]);
  191.      IfPtrThenWrite(laddr,r.r[2]);
  192.      IfPtrThenWrite(eaddr,r.r[3]);
  193.      IfPtrThenWrite(length,r.r[4]);
  194.      IfPtrThenWrite(attrib,r.r[5]);
  195.   }
  196.   return(last_oserror);
  197. }
  198.            
  199.  
  200.  
  201. /*
  202.  * Name : file_delete ( char *filename )
  203.  * Desc : deletes a named file
  204.  * In   : char *filename   - the name of the file
  205.  * Out  : pointer to an error block
  206.  */
  207.  
  208. extern _kernel_oserror *file_delete ( char *filename )
  209. {
  210. _kernel_swi_regs  r;
  211.  
  212.   r.r[0] = Delete;
  213.   r.r[1] = (int) filename;
  214.   return((last_oserror = _kernel_swi(OS_File,&r,&r)));
  215. }
  216.  
  217.  
  218.  
  219. /*
  220.  * Name : file_createfile
  221.  * Desc : creates an empty file of specified size
  222.  * In   : char *filename     - name of file to create
  223.  *        int   filetype     - filetype
  224.  *        int   size         - size of file to create
  225.  * Out  : pointer to an error block
  226.  */
  227.  
  228. extern _kernel_oserror *file_createfile ( char *filename, int filetype, int size )
  229. {
  230. _kernel_swi_regs r;
  231.  
  232.   r.r[0] = CreateFile;
  233.   r.r[1] = (int) filename;
  234.   r.r[2] = filetype;
  235.   r.r[4] = 0;
  236.   r.r[5] = size;
  237.   return((last_oserror = _kernel_swi(OS_File,&r,&r)));
  238. }
  239.  
  240.  
  241.  
  242. /*
  243.  * Name : file_createdir
  244.  * Desc : creates a directory
  245.  * In   : char *filename  - name of directory
  246.  *        int entries     - number of files allowed in directory
  247.  * Out  : pointer to an error block
  248.  */
  249.  
  250. extern _kernel_oserror *file_createdir ( char *filename, int entries )
  251. {
  252. _kernel_swi_regs r;
  253.  
  254.   r.r[0] = CreateDir;
  255.   r.r[1] = (int) filename;
  256.   r.r[4] = entries;
  257.   return((last_oserror = _kernel_swi(OS_File,&r,&r)));
  258. }
  259.  
  260.  
  261.   
  262. /*
  263.  * Name : file_load
  264.  * Desc : loads a named file into memory
  265.  * In   : char *filename    - name of file to load
  266.  *        int   address     - address of memory to load file in
  267.  * Out  : pointer to error block
  268.  */
  269.  
  270. extern _kernel_oserror *file_load ( char *filename, int address )
  271. {
  272. _kernel_swi_regs r;
  273.  
  274.   r.r[0] = LoadFile;
  275.   r.r[1] = (int) filename;
  276.   r.r[2] = address;
  277.   r.r[3] = 0;
  278.   last_oserror = _kernel_swi(OS_File,&r,&r);
  279.   return(last_oserror);
  280. }
  281.  
  282.  
  283.  
  284. /**********************************************************
  285.  * OS_Args calls                                          *
  286.  * -------------                                          *
  287.  *                                                        *
  288.  * These calls call the SWI' as detailed in the RISC OS   *
  289.  * v2.00 PRM                                              *
  290.  *                                                        *
  291.  * They deal mainly with the reading of open files        *
  292.  * arguments                                              *
  293.  *                                                        *
  294.  **********************************************************/
  295.  
  296.   
  297. /*************************************************
  298.  * Reason codes etc                              *
  299.  *************************************************/
  300.  
  301. /*-- OS Args --*/
  302.  
  303. #define OS_Args     0x09
  304. #define ReadSeqPtr     0
  305. #define WriteSeqPtr    1
  306. #define ReadExt        2
  307. #define WriteExt       3
  308. #define ReadSize       4
  309. #define ReadEOF        5
  310. #define EnsureSize     6
  311. #define HandleInfo   254
  312. #define Flush        255
  313.  
  314. /*
  315.  * Name : file_read_seqptr
  316.  * Desc : reads the files sequential pointer
  317.  * In   : int  handle   - file handle
  318.  *        int *seqptr   - desination for seq ptr
  319.  * Out  : pointer to error block
  320.  */
  321.  
  322. extern _kernel_oserror *file_read_seqptr ( int handle, int *seqptr )
  323. {
  324. _kernel_swi_regs r;
  325.  
  326.   r.r[0] = ReadSeqPtr;
  327.   r.r[1] = handle;
  328.   if((last_oserror = _kernel_swi(OS_Args,&r,&r)) == NULL)
  329.     *seqptr = r.r[2];
  330.   return(last_oserror);
  331. }
  332.                    
  333.  
  334.  
  335. /*
  336.  * Name : file_write_seqptr
  337.  * Desc : writes the files sequential pointer
  338.  * In   : int  handle  - file handle
  339.  *        int  seqptr  - new seq ptr
  340.  * Out  : pointer to error block
  341.  */
  342.  
  343. extern _kernel_oserror *file_write_seqptr ( int handle, int seqptr )
  344. {
  345. _kernel_swi_regs  r;
  346.  
  347.   r.r[0] = WriteSeqPtr;
  348.   r.r[1] = handle;
  349.   r.r[2] = seqptr;
  350.   return((last_oserror = _kernel_swi(OS_Args,&r,&r)));
  351. }
  352.  
  353.  
  354.  
  355. /*
  356.  * Name : file_read_ext
  357.  * Desc : reads a files open extent
  358.  * In   : int  handle   - file handle
  359.  *        int *ext      - destination for extent
  360.  * Out  : pointer to error block
  361.  */
  362.  
  363. extern _kernel_oserror *file_read_ext ( int handle, int *ext )
  364. {
  365. _kernel_swi_regs r;
  366.  
  367.   r.r[0] = ReadExt;
  368.   r.r[1] = handle;
  369.   if((last_oserror = _kernel_swi(OS_Args,&r,&r)) == NULL)
  370.     *ext = r.r[2];
  371.   return(last_oserror);
  372. }
  373.  
  374.  
  375.  
  376. /*
  377.  * Name : file_write_ext
  378.  * Desc : writes a files open extent
  379.  * In   : int  handle   - file handle
  380.  *        int  ext      - new extent
  381.  * Out  : pointer to error block
  382.  */
  383.  
  384. extern _kernel_oserror *file_write_ext ( int handle, int ext )
  385. {
  386. _kernel_swi_regs r;
  387.  
  388.   r.r[0] = ReadExt;
  389.   r.r[1] = handle;
  390.   r.r[2] = ext;
  391.   return((last_oserror = _kernel_swi(OS_Args,&r,&r)));
  392. }                                                     
  393.  
  394.  
  395.  
  396. /*
  397.  * Name : file_read_allocsize
  398.  * Desc : reads a files allocated size
  399.  * In   : int  handle   - file handle
  400.  *        int *size     - destination for size
  401.  * Out  : pointer to error block
  402.  */
  403.  
  404. extern _kernel_oserror *file_read_allocsize ( int handle, int *size )
  405. {
  406. _kernel_swi_regs r;
  407.  
  408.   r.r[0] = ReadSize;
  409.   r.r[1] = handle;
  410.   if((last_oserror = _kernel_swi(OS_Args,&r,&r)) == NULL)
  411.     *size = r.r[2];
  412.   return(last_oserror);
  413. }
  414.                       
  415.  
  416.  
  417. /*
  418.  * Name : file_read_EOF
  419.  * Desc : reads a files EOF state
  420.  * In   : int  handle - files handle
  421.  * Out  : TRUE if EOF else FALSE
  422.  */
  423.  
  424. extern BOOL file_read_eof ( int handle )
  425. {
  426. _kernel_swi_regs  r;
  427.  
  428.   r.r[0] = ReadEOF;
  429.   r.r[1] = handle;
  430.   last_oserror = _kernel_swi(OS_Args,&r,&r);
  431.   return(r.r[2]);
  432. }
  433.  
  434.  
  435.  
  436. /*
  437.  * Name : file_ensure_size
  438.  * Desc : Ensures an open files size
  439.  * In   : int  handle  - file handle
  440.  *        int  size    - size to ensure to
  441.  * Out  : Pointer to error block
  442.  */
  443.  
  444. extern _kernel_oserror *file_ensure_size ( int handle, int size )
  445. {
  446. _kernel_swi_regs r;
  447.  
  448.   r.r[0] = EnsureSize;
  449.   r.r[1] = handle;
  450.   r.r[2] = size;
  451.   return((last_oserror = _kernel_swi(OS_Args,&r,&r)));
  452. }
  453.        
  454.             
  455.  
  456. #ifndef FILE_INFO_BITS_DEFINED
  457. #define FILE_INFO_BITS_DEFINED
  458. #define STREAM_INTERACTIVE       4
  459. #define STREAM_SUPPORTS_GBPB     8
  460. #define OBJECT_DIRECTORY        16
  461. #define READ_ACCESS             32
  462. #define WRITE_ACCESS            64
  463. #define OBJECT_WRITTEN         128
  464. #define END_OF_FILE            256
  465. #define STREAM_UNBUFFERED      512
  466. #define STREAM_UNALLOCATED    1024
  467. #define STREAM_CRITICAL       2048
  468. #define DATA_LOST             4096
  469. #endif
  470.  
  471.  
  472. /*
  473.  * Name : file_read_handleinfo 
  474.  * Desc : reads information on a files handle
  475.  * In   : int handle   - file handle
  476.  * Out  : status of file handle
  477.  */
  478.  
  479. extern int file_read_handleinfo ( int handle )
  480. {
  481. _kernel_swi_regs  r;
  482.  
  483.   r.r[0] = HandleInfo;
  484.   r.r[1] = handle;
  485.   last_oserror = _kernel_swi(OS_Args,&r,&r);
  486.   return(r.r[0]);
  487. }
  488.  
  489.  
  490.  
  491. /*
  492.  * Name : file_flush
  493.  * Desc : ensres that all buffered data is written
  494.  * In   : int  handle   - file handle
  495.  * Out  : pointer to error block
  496.  */
  497.  
  498. extern _kernel_oserror *file_flush ( int handle )
  499. {
  500. _kernel_swi_regs r;
  501.  
  502.   r.r[0] = Flush;
  503.   r.r[1] = handle;
  504.   return((last_oserror = _kernel_swi(OS_Args,&r,&r)));
  505. }
  506.  
  507.  
  508.  
  509. /**********************************************************
  510.  * OS_BGet/BPut & OS_GBPB                                 *
  511.  * ----------------------                                 *
  512.  *                                                        *
  513.  * These calls call the SWI' as detailed in the RISC OS   *
  514.  * v2.00 PRM                                              *
  515.  *                                                        *
  516.  * They deal mainly with the reading and writing of       *
  517.  * byte(s) to open files                                  *
  518.  *                                                        *
  519.  **********************************************************/
  520.  
  521.   
  522. /*************************************************
  523.  * Reason codes etc                              *
  524.  *************************************************/
  525.  
  526. #define OS_BGet        0x0A
  527. #define OS_BPut        0x0B
  528. #define OS_GBPB        0x0C
  529. #define WriteBytesSEQ     1
  530. #define WriteBytes        2
  531. #define ReadBytesSEQ      3
  532. #define ReadBytes         4
  533.  
  534.  
  535. /*
  536.  * Name : file_readabyte
  537.  * Desc : reads a byte from an open file
  538.  * In   : int handle   - file handle
  539.  * Out  : int          - byte read
  540.  * Info : will return -1 if an error is encountered
  541.  */
  542.  
  543. extern int file_readabyte ( int handle )
  544. {
  545. _kernel_swi_regs  r;
  546.  
  547.   r.r[1] = handle;
  548.   last_oserror = _kernel_swi(OS_BGet,&r,&r);
  549.   if(last_oserror != NULL)
  550.     return(-1);
  551.   return(r.r[0]);
  552. }
  553.  
  554.  
  555.  
  556. /*
  557.  * Name : file_writeabyte
  558.  * Desc : writes a byte to an open file
  559.  * In   : int handle    - file handle
  560.  *        int byte      - byte to write
  561.  * Out  : pointer to error block
  562.  */
  563.  
  564. extern _kernel_oserror *file_writeabyte ( int handle, int byte )
  565. {
  566. _kernel_swi_regs  r;
  567.  
  568.   r.r[0] = byte;
  569.   r.r[1] = handle;
  570.   return((last_oserror = _kernel_swi(OS_BPut,&r,&r)));
  571. }
  572.  
  573.  
  574.  
  575. /*
  576.  * Name : file_writebytes
  577.  * Desc : writes a buffer to an open file
  578.  * In   : int   handle     - file handle
  579.  *        char *buffer     - pointer to buffer to write
  580.  *        int   offset     - offset in buffer to write from
  581.  *        int   nwrite     - number of bytes to write to file
  582.  *        int   seqptr     - sequential file pointer
  583.  * Out  : pointer to error block    
  584.  * Info : if seqptr == -1 then writing will start from current
  585.  *        sequential file pointer
  586.  */
  587.  
  588. extern _kernel_oserror *file_writebytes ( int handle, char *buffer,
  589.                                           int offset, int nwrite,
  590.                                           int seqptr               )
  591. {                                
  592. _kernel_swi_regs  r;
  593.  
  594.   if(seqptr == -1)
  595.     r.r[0] = WriteBytes;
  596.   else
  597.     r.r[0] = WriteBytesSEQ;
  598.   r.r[1] = handle;
  599.   r.r[2] = ((int) buffer) + offset;
  600.   r.r[3] = nwrite;
  601.   if(r.r[0] == WriteBytesSEQ)
  602.     r.r[4] = seqptr;
  603.   last_oserror = _kernel_swi(OS_GBPB,&r,&r);
  604.   return(last_oserror);
  605. }
  606.  
  607.  
  608.  
  609.  
  610. /*
  611.  * Name : file_readbytes
  612.  * Desc : writes a buffer to an open file
  613.  * In   : int   handle     - file handle
  614.  *        int   buffer     - pointer to buffer 
  615.  *        int   nread      - number of bytes to read
  616.  *        int   seqptr     - sequential file pointer
  617.  * Out  : pointer to error block    
  618.  * Info : if seqptr == -1 then writing will start from current
  619.  *        sequential file pointer
  620.  */
  621.  
  622. extern _kernel_oserror *file_readbytes  ( int handle, char *buffer,
  623.                                           int nread,  int seqptr  )
  624. {                                
  625. _kernel_swi_regs  r;
  626.  
  627.   if(seqptr == -1)
  628.     r.r[0] = ReadBytes;
  629.   else
  630.     r.r[0] = ReadBytesSEQ;
  631.   r.r[1] = handle;
  632.   r.r[2] = (int) buffer;
  633.   r.r[3] = nread;
  634.   if(r.r[0] == ReadBytesSEQ)
  635.     r.r[4] = seqptr;
  636.   last_oserror = _kernel_swi(OS_GBPB,&r,&r);
  637.   return(last_oserror);
  638. }
  639.  
  640.  
  641.  
  642. /**********************************************************
  643.  * OS_Find                                                *
  644.  * -------                                                *
  645.  *                                                        *
  646.  * These calls call the SWI' as detailed in the RISC OS   *
  647.  * v2.00 PRM                                              *
  648.  *                                                        *
  649.  * They deal mainly with the opening of files             *
  650.  *                                                        *
  651.  **********************************************************/
  652.  
  653.   
  654. /*************************************************
  655.  * Reason codes etc                              *
  656.  *************************************************/
  657.  
  658. #define OS_Find     0x0D
  659.  
  660. #ifndef OPEN_TYPES
  661. #define OPEN_TYPES
  662. #define OPEN_EXIST_READ         "r"
  663. #define OPEN_NEW_READ_WRITE     "wr"
  664. #define OPEN_EXIST_READ_WRITE   "wr+"
  665. #endif
  666.  
  667. /*
  668.  * Name : file_open 
  669.  * Desc : opens a specified file
  670.  * In   : char *filename    - the file to open
  671.  *        int  *handle      - destination for file handle
  672.  *        char *oa          - open access indicator
  673.  * Out  : pointer to error block
  674.  */
  675.  
  676. extern _kernel_oserror *file_open ( char *filename, int *handle, char *oa )
  677. {
  678. _kernel_swi_regs  r;
  679.  
  680.   if(strcmp(oa,OPEN_EXIST_READ) == 0)
  681.     r.r[0] = 0x4C;
  682.   else
  683.   {
  684.     if(strcmp(oa,OPEN_NEW_READ_WRITE) == 0)
  685.       r.r[0] = 0x8C;
  686.     else
  687.     {
  688.       if(strcmp(oa,OPEN_EXIST_READ_WRITE) == 0)
  689.         r.r[0] = 0xCC;
  690.       else
  691.       {
  692.          r.r[0] = 0x4C;
  693.       }
  694.     }
  695.   }
  696.   r.r[1] = (int) filename;
  697.   last_oserror = _kernel_swi(OS_Find,&r,&r);
  698.   *handle = r.r[0];
  699.   return(last_oserror);
  700. }
  701.  
  702.  
  703.  
  704. /*
  705.  * Name : file_close 
  706.  * Desc : closes a file
  707.  * In   : int handle  -  file handle
  708.  * Out  : pointer to error block
  709.  */
  710.      
  711. extern _kernel_oserror *file_close ( int handle )
  712. {
  713. _kernel_swi_regs r;
  714.  
  715.   r.r[0] = 0;
  716.   r.r[1] = handle;
  717.   return((last_oserror = _kernel_swi(OS_Find,&r,&r)));
  718. }
  719.  
  720. /*****************************************
  721.  * End                                   *
  722.  *****************************************/
  723.  
  724.